@wong2kim/wmux 1.1.1 → 1.1.2

package/README.md

@@ -14,7 +14,7 @@ Inspired by [cmux](https://github.com/manaflow-ai/cmux) (macOS), wmux brings the
 
 ## Install
 
-**Download:** [wmux-1.1.1 Setup.exe](https://github.com/openwong2kim/wmux/releases/latest)
+**Download:** [wmux-1.1.2 Setup.exe](https://github.com/openwong2kim/wmux/releases/latest)
 
 Or build from source:
 ```powershell
@@ -45,13 +45,14 @@ irm https://raw.githubusercontent.com/openwong2kim/wmux/main/install.ps1 | iex
 - **Vi copy mode** — `Ctrl+Shift+X`
 - **Search** — `Ctrl+F`
 - **Unlimited scrollback** — 999,999 lines default
+- **Scrollback persistence** — terminal content saved to disk, restored on restart
 
 ### Workspaces
 - Sidebar with drag-and-drop reordering
 - `Ctrl+1` ~ `Ctrl+9` quick switch
 - **Multiview** — `Ctrl+click` workspaces to split-view them simultaneously
 - `Ctrl+Shift+G` to exit multiview
-- Session persistence — everything restored on restart
+- **Session persistence** — workspace layout, tabs, cwd, and terminal scrollback all restored on restart
 
 ### Browser
 - Built-in browser panel — `Ctrl+Shift+L`
@@ -171,20 +172,29 @@ The `install.ps1` script auto-installs Python and VS Build Tools if missing.
 
 ```
 Electron Main Process
-├── PTYManager (node-pty)
+├── PTYManager (node-pty / ConPTY)
 ├── PTYBridge (data forwarding + ActivityMonitor)
 ├── AgentDetector (gate-based agent status)
+├── SessionManager (atomic save with .bak recovery)
+├── ScrollbackPersistence (dump/load terminal buffers)
 ├── PipeServer (Named Pipe JSON-RPC)
 ├── McpRegistrar (auto-registers MCP in ~/.claude.json)
+├── DaemonClient (optional daemon mode connector)
 └── ToastManager (OS notifications + taskbar flash)
 
 Renderer Process (React 19 + Zustand)
 ├── PaneContainer (recursive split layout)
-├── Terminal (xterm.js + WebGL)
+├── Terminal (xterm.js + WebGL + scrollback restore)
 ├── BrowserPanel (webview + Inspector)
 ├── NotificationPanel
 └── Multiview grid
 
+Daemon Process (optional, standalone)
+├── DaemonSessionManager (ConPTY lifecycle)
+├── RingBuffer (circular scrollback buffer)
+├── StateWriter (session suspend/resume)
+└── DaemonPipeServer (Named Pipe RPC)
+
 MCP Server (stdio)
 └── Bridges Claude Code ↔ wmux via Named Pipe RPC
 ```

package/dist/cli/cli/commands/browser.js

@@ -4,24 +4,25 @@ exports.handleBrowser = handleBrowser;
 const client_1 = require("../client");
 const utils_1 = require("../utils");
 const BROWSER_HELP = `
-wmux browser — Scriptable Browser API
+wmux browser — Browser Commands
 
 USAGE
   wmux browser <subcommand> [args]
 
 SUBCOMMANDS
-  snapshot                        Return the full page HTML (document.documentElement.outerHTML)
-  click <selector>                Click the first element matching the CSS selector
-  fill <selector> <text>          Set the value of an input matching the CSS selector
-  eval <code>                     Execute arbitrary JavaScript in the page context
   navigate <url>                  Navigate the active browser surface to a URL
+  close                           Close the browser panel
+  session start [--profile <name>]  Start a browser session
+  session stop                      Stop the active browser session
+  session status                    Show active session status
+  session list                      List available profiles
 
 EXAMPLES
-  wmux browser snapshot
-  wmux browser click "#submit-btn"
-  wmux browser fill "input[name=email]" "user@example.com"
-  wmux browser eval "document.title"
   wmux browser navigate "https://example.com"
+  wmux browser close
+  wmux browser session start --profile login
+  wmux browser session status
+  wmux browser session list
 `.trimStart();
 async function handleBrowser(args, jsonMode) {
     const sub = args[0];
@@ -32,30 +33,14 @@ async function handleBrowser(args, jsonMode) {
     }
     let response;
     switch (sub) {
-        // ── browser snapshot ─────────────────────────────────────────────────────
-        case 'snapshot': {
-            response = await (0, client_1.sendRequest)('browser.snapshot', {});
-            if (jsonMode) {
-                (0, utils_1.printResult)(response);
-            }
-            else {
-                if (!response.ok) {
-                    (0, utils_1.printError)(response);
-                    return;
-                }
-                const r = response.result;
-                process.stdout.write(r?.html ?? '');
-            }
-            break;
-        }
-        // ── browser click <selector> ─────────────────────────────────────────────
-        case 'click': {
-            const selector = rest[0];
-            if (!selector) {
-                console.error('Error: browser click requires <selector>');
+        // ── browser navigate <url> ───────────────────────────────────────────────
+        case 'navigate': {
+            const url = rest[0];
+            if (!url) {
+                console.error('Error: browser navigate requires <url>');
                 process.exit(1);
             }
-            response = await (0, client_1.sendRequest)('browser.click', { selector });
+            response = await (0, client_1.sendRequest)('browser.navigate', { url });
             if (jsonMode) {
                 (0, utils_1.printResult)(response);
             }
@@ -64,19 +49,13 @@ async function handleBrowser(args, jsonMode) {
                     (0, utils_1.printError)(response);
                     return;
                 }
-                console.log(`Clicked: ${selector}`);
+                console.log(`Navigated to: ${url}`);
             }
             break;
         }
-        // ── browser fill <selector> <text> ───────────────────────────────────────
-        case 'fill': {
-            const selector = rest[0];
-            const text = rest.slice(1).join(' ');
-            if (!selector) {
-                console.error('Error: browser fill requires <selector> <text>');
-                process.exit(1);
-            }
-            response = await (0, client_1.sendRequest)('browser.fill', { selector, text });
+        // ── browser close ────────────────────────────────────────────────────────
+        case 'close': {
+            response = await (0, client_1.sendRequest)('browser.close', {});
             if (jsonMode) {
                 (0, utils_1.printResult)(response);
             }
@@ -85,48 +64,93 @@ async function handleBrowser(args, jsonMode) {
                     (0, utils_1.printError)(response);
                     return;
                 }
-                console.log(`Filled "${selector}" with "${text}"`);
+                console.log('Browser panel closed.');
             }
             break;
         }
-        // ── browser eval <code> ──────────────────────────────────────────────────
-        case 'eval': {
-            const code = rest.join(' ');
-            if (!code) {
-                console.error('Error: browser eval requires <code>');
-                process.exit(1);
-            }
-            response = await (0, client_1.sendRequest)('browser.eval', { code });
-            if (jsonMode) {
-                (0, utils_1.printResult)(response);
+        // ── browser session <action> ─────────────────────────────────────────────
+        case 'session': {
+            const action = rest[0];
+            if (!action || action === '--help' || action === '-h') {
+                console.log('Usage: wmux browser session <start|stop|status|list>');
+                process.exit(0);
             }
-            else {
-                if (!response.ok) {
-                    (0, utils_1.printError)(response);
-                    return;
+            switch (action) {
+                case 'start': {
+                    const profileIdx = rest.indexOf('--profile');
+                    const profile = profileIdx !== -1 ? rest[profileIdx + 1] : undefined;
+                    const params = {};
+                    if (profile)
+                        params['profile'] = profile;
+                    response = await (0, client_1.sendRequest)('browser.session.start', params);
+                    if (jsonMode) {
+                        (0, utils_1.printResult)(response);
+                    }
+                    else {
+                        if (!response.ok) {
+                            (0, utils_1.printError)(response);
+                            return;
+                        }
+                        const r = response.result;
+                        console.log(`Session started with profile: ${r['profile'] ?? 'default'}`);
+                    }
+                    break;
                 }
-                const r = response.result;
-                console.log(JSON.stringify(r?.result, null, 2));
-            }
-            break;
-        }
-        // ── browser navigate <url> ───────────────────────────────────────────────
-        case 'navigate': {
-            const url = rest[0];
-            if (!url) {
-                console.error('Error: browser navigate requires <url>');
-                process.exit(1);
-            }
-            response = await (0, client_1.sendRequest)('browser.navigate', { url });
-            if (jsonMode) {
-                (0, utils_1.printResult)(response);
-            }
-            else {
-                if (!response.ok) {
-                    (0, utils_1.printError)(response);
-                    return;
+                case 'stop': {
+                    response = await (0, client_1.sendRequest)('browser.session.stop', {});
+                    if (jsonMode) {
+                        (0, utils_1.printResult)(response);
+                    }
+                    else {
+                        if (!response.ok) {
+                            (0, utils_1.printError)(response);
+                            return;
+                        }
+                        console.log('Session stopped.');
+                    }
+                    break;
                 }
-                console.log(`Navigated to: ${url}`);
+                case 'status': {
+                    response = await (0, client_1.sendRequest)('browser.session.status', {});
+                    if (jsonMode) {
+                        (0, utils_1.printResult)(response);
+                    }
+                    else {
+                        if (!response.ok) {
+                            (0, utils_1.printError)(response);
+                            return;
+                        }
+                        const r = response.result;
+                        console.log(`Active profile: ${r['profile'] ?? 'none'}`);
+                        console.log(`CDP port: ${r['port'] ?? 'none'}`);
+                    }
+                    break;
+                }
+                case 'list': {
+                    response = await (0, client_1.sendRequest)('browser.session.list', {});
+                    if (jsonMode) {
+                        (0, utils_1.printResult)(response);
+                    }
+                    else {
+                        if (!response.ok) {
+                            (0, utils_1.printError)(response);
+                            return;
+                        }
+                        const profiles = response.result['profiles'];
+                        if (!profiles || profiles.length === 0) {
+                            console.log('No profiles found.');
+                        }
+                        else {
+                            for (const p of profiles) {
+                                console.log(`  ${p['name']}  (partition: ${p['partition']}, persistent: ${p['persistent']})`);
+                            }
+                        }
+                    }
+                    break;
+                }
+                default:
+                    console.error(`Unknown session action: "${action}". Use start, stop, status, or list.`);
+                    process.exit(1);
             }
             break;
         }

package/dist/cli/cli/index.js

@@ -51,11 +51,12 @@ SYSTEM COMMANDS
   capabilities                      List all supported RPC methods
 
 BROWSER COMMANDS
-  browser snapshot                  Return the full page HTML of the active browser surface
-  browser click <selector>          Click an element by CSS selector
-  browser fill <selector> <text>    Fill an input field by CSS selector
-  browser eval <code>               Execute JavaScript in the browser context
   browser navigate <url>            Navigate the browser surface to a URL
+  browser close                     Close the browser panel
+  browser session start [--profile <name>]  Start a browser session
+  browser session stop              Stop the active browser session
+  browser session status            Show active session status
+  browser session list              List available profiles
 
 GLOBAL FLAGS
   --json      Output raw JSON (useful for scripting)
@@ -67,9 +68,8 @@ EXAMPLES
   wmux send "echo hello"
   wmux notify --title "Done" --body "Build finished"
   wmux identify --json
-  wmux browser snapshot
   wmux browser navigate "https://example.com"
-  wmux browser click "#login-btn"
+  wmux browser close
 `.trimStart();
 const WORKSPACE_CMDS = new Set([
     'list-workspaces',

package/dist/cli/shared/constants.js

@@ -45,6 +45,9 @@ exports.IPC = {
     FS_WATCH: 'fs:watch',
     FS_UNWATCH: 'fs:unwatch',
     FS_CHANGED: 'fs:changed',
+    // Scrollback persistence
+    SCROLLBACK_DUMP: 'scrollback:dump',
+    SCROLLBACK_LOAD: 'scrollback:load',
 };
 // Named Pipe / Unix socket path for wmux API
 // Fixed name so MCP clients (e.g. Claude Code) can reconnect across wmux restarts

package/dist/cli/shared/rpc.js

@@ -25,9 +25,20 @@ exports.ALL_RPC_METHODS = [
     'system.identify',
     'system.capabilities',
     'browser.open',
-    'browser.snapshot',
-    'browser.click',
-    'browser.fill',
-    'browser.eval',
     'browser.navigate',
+    'browser.close',
+    'browser.session.start',
+    'browser.session.stop',
+    'browser.session.status',
+    'browser.session.list',
+    'browser.type.humanlike',
+    'browser.cdp.target',
+    'browser.cdp.info',
+    'daemon.createSession',
+    'daemon.destroySession',
+    'daemon.attachSession',
+    'daemon.detachSession',
+    'daemon.resizeSession',
+    'daemon.listSessions',
+    'daemon.ping',
 ];

package/dist/mcp/mcp/index.js

@@ -5,6 +5,15 @@ const mcp_js_1 = require("@modelcontextprotocol/sdk/server/mcp.js");
 const stdio_js_1 = require("@modelcontextprotocol/sdk/server/stdio.js");
 const zod_1 = require("zod");
 const wmux_client_1 = require("./wmux-client");
+const PlaywrightEngine_1 = require("./playwright/PlaywrightEngine");
+const navigation_1 = require("./playwright/tools/navigation");
+const interaction_1 = require("./playwright/tools/interaction");
+const inspection_1 = require("./playwright/tools/inspection");
+const state_1 = require("./playwright/tools/state");
+const wait_1 = require("./playwright/tools/wait");
+const file_1 = require("./playwright/tools/file");
+const utility_1 = require("./playwright/tools/utility");
+const extraction_1 = require("./playwright/tools/extraction");
 const server = new mcp_js_1.McpServer({
     name: 'wmux',
     version: '1.0.0',
@@ -15,30 +24,29 @@ async function callRpc(method, params = {}) {
     const text = typeof result === 'string' ? result : JSON.stringify(result, null, 2);
     return { content: [{ type: 'text', text }] };
 }
-// Optional surfaceId schema used by browser and terminal tools
-const optionalSurfaceId = zod_1.z.string().optional().describe('Target a specific surface by ID. Omit to use the active surface.');
-// === Browser tools ===
+// === Browser tools (RPC-based: surface management stays in main process) ===
 server.tool('browser_open', 'Open a new browser panel in the active pane. Use this when no browser surface exists yet.', {
     url: zod_1.z.string().optional().describe('Initial URL to load (defaults to google.com)'),
 }, async ({ url }) => callRpc('browser.open', url ? { url } : {}));
-server.tool('browser_navigate', 'Navigate the wmux browser panel to a URL', {
-    url: zod_1.z.string().describe('The URL to navigate to'),
-    surfaceId: optionalSurfaceId,
-}, async ({ url, surfaceId }) => callRpc('browser.navigate', { url, ...(surfaceId && { surfaceId }) }));
-server.tool('browser_snapshot', 'Get the full HTML content of the current page in the wmux browser panel', { surfaceId: optionalSurfaceId }, async ({ surfaceId }) => callRpc('browser.snapshot', surfaceId ? { surfaceId } : {}));
-server.tool('browser_click', 'Click an element in the wmux browser panel by CSS selector', {
-    selector: zod_1.z.string().describe('CSS selector of the element to click'),
-    surfaceId: optionalSurfaceId,
-}, async ({ selector, surfaceId }) => callRpc('browser.click', { selector, ...(surfaceId && { surfaceId }) }));
-server.tool('browser_fill', 'Fill an input field in the wmux browser panel by CSS selector', {
-    selector: zod_1.z.string().describe('CSS selector of the input element'),
-    text: zod_1.z.string().describe('Text to fill into the input'),
-    surfaceId: optionalSurfaceId,
-}, async ({ selector, text, surfaceId }) => callRpc('browser.fill', { selector, text, ...(surfaceId && { surfaceId }) }));
-server.tool('browser_eval', 'Execute JavaScript in the wmux browser panel and return the result', {
-    code: zod_1.z.string().describe('JavaScript code to execute in the browser context'),
-    surfaceId: optionalSurfaceId,
-}, async ({ code, surfaceId }) => callRpc('browser.eval', { code, ...(surfaceId && { surfaceId }) }));
+server.tool('browser_close', 'Close the browser panel in the active pane', {
+    surfaceId: zod_1.z.string().optional().describe('Target a specific surface by ID. Omit to use the active surface.'),
+}, async ({ surfaceId }) => callRpc('browser.close', surfaceId ? { surfaceId } : {}));
+// === Playwright browser tools ===
+(0, navigation_1.registerNavigationTools)(server);
+(0, interaction_1.registerInteractionTools)(server);
+(0, inspection_1.registerInspectionTools)(server);
+(0, state_1.registerStateTools)(server);
+(0, wait_1.registerWaitTools)(server);
+(0, file_1.registerFileTools)(server);
+(0, utility_1.registerUtilityTools)(server);
+(0, extraction_1.registerExtractionTools)(server);
+// === Browser session tools ===
+server.tool('browser_session_start', 'Start a browser session with the specified profile', {
+    profile: zod_1.z.string().optional().describe('Profile name to use (defaults to "default")'),
+}, async ({ profile }) => callRpc('browser.session.start', profile ? { profile } : {}));
+server.tool('browser_session_stop', 'Stop the current browser session', {}, async () => callRpc('browser.session.stop'));
+server.tool('browser_session_status', 'Get current browser session status', {}, async () => callRpc('browser.session.status'));
+server.tool('browser_session_list', 'List available browser profiles', {}, async () => callRpc('browser.session.list'));
 // === Terminal tools ===
 server.tool('terminal_read', 'Read the current visible text from the active terminal in wmux', {}, async () => callRpc('input.readScreen'));
 server.tool('terminal_send', 'Send text to the active terminal in wmux', { text: zod_1.z.string().describe('Text to send to the terminal') }, async ({ text }) => callRpc('input.send', { text }));
@@ -53,6 +61,18 @@ server.tool('pane_list', 'List all panes in the current workspace', {}, async ()
 async function main() {
     const transport = new stdio_js_1.StdioServerTransport();
     await server.connect(transport);
+    // Clean up Playwright connection when transport closes
+    transport.onclose = async () => {
+        console.log('[wmux-mcp] Transport closed, disconnecting Playwright');
+        await PlaywrightEngine_1.PlaywrightEngine.getInstance().disconnect();
+    };
+    // Graceful shutdown
+    const shutdown = async () => {
+        await PlaywrightEngine_1.PlaywrightEngine.getInstance().disconnect();
+        process.exit(0);
+    };
+    process.on('SIGTERM', shutdown);
+    process.on('SIGINT', shutdown);
 }
 main().catch((err) => {
     console.error('wmux MCP server failed to start:', err);

package/dist/mcp/mcp/playwright/PlaywrightEngine.js

@@ -0,0 +1,186 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PlaywrightEngine = void 0;
+const playwright_core_1 = require("playwright-core");
+const wmux_client_1 = require("../wmux-client");
+const MAX_CONNECT_RETRIES = 3;
+const RETRY_DELAY_MS = 1000;
+const PAGE_FIND_RETRIES = 5;
+const PAGE_FIND_DELAY_MS = 800;
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+/**
+ * Returns true if the URL belongs to the Electron main renderer window.
+ * Navigating these pages would destroy the app — they must never be returned.
+ */
+function isElectronShellUrl(url) {
+    return (url.startsWith('http://localhost:') ||
+        url.startsWith('devtools://') ||
+        url.startsWith('chrome://'));
+}
+/**
+ * PlaywrightEngine -- singleton wrapper around playwright-core's Chromium CDP connection.
+ *
+ * Connects to the wmux Electron app via Chrome DevTools Protocol and provides
+ * access to browser pages for automation.
+ */
+class PlaywrightEngine {
+    constructor() {
+        this.browser = null;
+        this.cdpPort = null;
+    }
+    static getInstance() {
+        if (!PlaywrightEngine.instance) {
+            PlaywrightEngine.instance = new PlaywrightEngine();
+        }
+        return PlaywrightEngine.instance;
+    }
+    async connect(cdpPort) {
+        if (this.browser && this.cdpPort === cdpPort && this.browser.isConnected()) {
+            return;
+        }
+        await this.disconnect();
+        this.browser = await playwright_core_1.chromium.connectOverCDP(`http://localhost:${cdpPort}`);
+        this.cdpPort = cdpPort;
+        console.log(`[PlaywrightEngine] Connected to CDP on port ${cdpPort}`);
+    }
+    async disconnect() {
+        if (this.browser) {
+            this.browser = null;
+            this.cdpPort = null;
+            console.log('[PlaywrightEngine] Disconnected');
+        }
+    }
+    /**
+     * Force reconnect — drops existing connection and creates a fresh one.
+     * Needed when new webviews are created after the initial connection,
+     * because connectOverCDP only discovers targets at connection time.
+     */
+    async reconnect() {
+        const info = (await (0, wmux_client_1.sendRpc)('browser.cdp.info'));
+        await this.disconnect();
+        await this.connect(info.cdpPort);
+    }
+    async ensureConnected() {
+        if (this.browser?.isConnected())
+            return;
+        for (let attempt = 1; attempt <= MAX_CONNECT_RETRIES; attempt++) {
+            try {
+                const info = (await (0, wmux_client_1.sendRpc)('browser.cdp.info'));
+                await this.connect(info.cdpPort);
+                return;
+            }
+            catch (err) {
+                console.warn(`[PlaywrightEngine] Connection attempt ${attempt}/${MAX_CONNECT_RETRIES} failed:`, err instanceof Error ? err.message : String(err));
+                if (attempt < MAX_CONNECT_RETRIES) {
+                    await sleep(RETRY_DELAY_MS);
+                }
+            }
+        }
+        throw new Error(`[PlaywrightEngine] Failed to connect after ${MAX_CONNECT_RETRIES} attempts`);
+    }
+    /**
+     * Collect all Playwright Page objects from all contexts.
+     */
+    getAllPages() {
+        if (!this.browser || !this.browser.isConnected())
+            return [];
+        const pages = [];
+        for (const ctx of this.browser.contexts()) {
+            pages.push(...ctx.pages());
+        }
+        return pages;
+    }
+    /**
+     * Fetch the CDP /json target list.
+     */
+    async fetchJsonTargets() {
+        if (!this.cdpPort)
+            return [];
+        const resp = await fetch(`http://127.0.0.1:${this.cdpPort}/json`);
+        return (await resp.json());
+    }
+    /**
+     * Try to find a Playwright Page that corresponds to a registered webview target.
+     * Returns null if no safe page can be found.
+     */
+    async findWebviewPage(allPages, target) {
+        // Strategy 1: Match by targetId → URL from /json endpoint
+        if (target) {
+            try {
+                const jsonTargets = await this.fetchJsonTargets();
+                const jsonTarget = jsonTargets.find((t) => t.id === target.targetId);
+                if (jsonTarget && !isElectronShellUrl(jsonTarget.url)) {
+                    // Find Playwright page with matching URL
+                    const matched = allPages.find((p) => p.url() === jsonTarget.url);
+                    if (matched)
+                        return matched;
+                    // URL might differ slightly (trailing slash, redirect) — try loose match
+                    const normalizedTarget = jsonTarget.url.replace(/\/+$/, '');
+                    const looseMatch = allPages.find((p) => p.url().replace(/\/+$/, '') === normalizedTarget);
+                    if (looseMatch)
+                        return looseMatch;
+                }
+            }
+            catch {
+                // /json fetch failed
+            }
+        }
+        // Strategy 2: Any page that isn't the Electron shell
+        // about:blank is allowed — webviews start there before navigating
+        const candidates = allPages.filter((p) => !isElectronShellUrl(p.url()));
+        if (candidates.length > 0) {
+            return candidates[0];
+        }
+        return null;
+    }
+    /**
+     * Get a Page matching the given surfaceId.
+     *
+     * Includes retry logic: if no webview page is found on the first attempt,
+     * reconnects to CDP (to discover newly created webview targets) and retries.
+     */
+    async getPage(surfaceId) {
+        await this.ensureConnected();
+        for (let attempt = 1; attempt <= PAGE_FIND_RETRIES; attempt++) {
+            const allPages = this.getAllPages();
+            if (allPages.length === 0 && attempt < PAGE_FIND_RETRIES) {
+                // No pages yet — reconnect to discover new targets
+                await sleep(PAGE_FIND_DELAY_MS);
+                await this.reconnect();
+                continue;
+            }
+            // Get registered webview targets
+            const info = (await (0, wmux_client_1.sendRpc)('browser.cdp.info'));
+            const target = surfaceId
+                ? info.targets.find((t) => t.surfaceId === surfaceId)
+                : info.targets[0];
+            // If no targets registered yet, wait for webview to initialize
+            if (!target && attempt < PAGE_FIND_RETRIES) {
+                console.log(`[PlaywrightEngine] No CDP targets registered yet, retry ${attempt}/${PAGE_FIND_RETRIES}...`);
+                await sleep(PAGE_FIND_DELAY_MS);
+                // Reconnect to pick up newly created webview targets
+                await this.reconnect();
+                continue;
+            }
+            const page = await this.findWebviewPage(allPages, target);
+            if (page)
+                return page;
+            // Page not found — reconnect and retry (new webview might not be visible yet)
+            if (attempt < PAGE_FIND_RETRIES) {
+                console.log(`[PlaywrightEngine] Webview page not found, reconnecting... (${attempt}/${PAGE_FIND_RETRIES})`);
+                await sleep(PAGE_FIND_DELAY_MS);
+                await this.reconnect();
+            }
+        }
+        console.warn('[PlaywrightEngine] No webview page found after all retries');
+        return null;
+    }
+    async getBrowser() {
+        await this.ensureConnected();
+        return this.browser;
+    }
+}
+exports.PlaywrightEngine = PlaywrightEngine;
+PlaywrightEngine.instance = null;